home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / PInterfaces / Menus.p < prev    next >
Encoding:
Text File  |  1996-05-05  |  11.1 KB  |  415 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Menus.p
  3.  
  4.      Contains:    Menu Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1.3
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Menus;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __MENUS__}
  30. {$SETC __MENUS__ := 1}
  31.  
  32. {$I+}
  33. {$SETC MenusIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __MEMORY__}
  38. {$I Memory.p}
  39. {$ENDC}
  40. {    Types.p                                                        }
  41. {        ConditionalMacros.p                                        }
  42. {    MixedMode.p                                                    }
  43.  
  44. {$IFC UNDEFINED __QUICKDRAW__}
  45. {$I Quickdraw.p}
  46. {$ENDC}
  47. {    QuickdrawText.p                                                }
  48.  
  49. {$PUSH}
  50. {$ALIGN MAC68K}
  51. {$LibExport+}
  52.  
  53. CONST
  54.     noMark                        = 0;                            {mark symbol for MarkItem}
  55. { menu defProc messages }
  56.     mDrawMsg                    = 0;
  57.     mChooseMsg                    = 1;
  58.     mSizeMsg                    = 2;
  59.     mDrawItemMsg                = 4;
  60.     mCalcItemMsg                = 5;
  61.     textMenuProc                = 0;
  62.     hMenuCmd                    = 27;                            {itemCmd == 0x001B ==> hierarchical menu}
  63.     hierMenu                    = -1;                            {a hierarchical menu - for InsertMenu call}
  64.     mPopUpMsg                    = 3;                            {menu defProc messages - place yourself}
  65.     mctAllItems                    = -98;                            {search for all Items for the given ID}
  66.     mctLastIDIndic                = -99;                            {last color table entry has this in ID field}
  67.  
  68. TYPE
  69.     MenuInfo = RECORD
  70.         menuID:                    INTEGER;
  71.         menuWidth:                INTEGER;
  72.         menuHeight:                INTEGER;
  73.         menuProc:                Handle;
  74.         enableFlags:            LONGINT;
  75.         menuData:                Str255;
  76.     END;
  77.  
  78.     MenuPtr = ^MenuInfo;
  79.     MenuHandle = ^MenuPtr;
  80.  
  81.     MenuRef = MenuHandle;
  82.  
  83.     MenuDefProcPtr = ProcPtr;  { PROCEDURE MenuDef(message: INTEGER; theMenu: MenuRef; VAR menuRect: Rect; hitPt: Point; VAR whichItem: INTEGER); }
  84.     MenuBarDefProcPtr = ProcPtr;  { FUNCTION MenuBarDef(selector: INTEGER; message: INTEGER; parameter1: INTEGER; parameter2: LONGINT): LONGINT; }
  85.     MenuHookProcPtr = ProcPtr;  { PROCEDURE MenuHook; }
  86.     MBarHookProcPtr = ProcPtr;  { FUNCTION MBarHook(VAR menuRect: Rect): INTEGER; }
  87.     MenuDefUPP = UniversalProcPtr;
  88.     MenuBarDefUPP = UniversalProcPtr;
  89.     MenuHookUPP = UniversalProcPtr;
  90.     MBarHookUPP = UniversalProcPtr;
  91.  
  92. CONST
  93.     uppMenuDefProcInfo = $0000FF80; { PROCEDURE (2 byte param, 4 byte param, 4 byte param, 4 byte param, 4 byte param); }
  94.     uppMenuBarDefProcInfo = $00003AB0; { FUNCTION (2 byte param, 2 byte param, 2 byte param, 4 byte param): 4 byte result; }
  95.     uppMenuHookProcInfo = $00000000; { PROCEDURE ; }
  96.     uppMBarHookProcInfo = $000000CF; { SPECIAL_CASE_PROCINFO( kSpecialCaseMBarHook ) }
  97.  
  98. FUNCTION NewMenuDefProc(userRoutine: MenuDefProcPtr): MenuDefUPP;
  99.     {$IFC NOT GENERATINGCFM }
  100.     INLINE $2E9F;
  101.     {$ENDC}
  102.  
  103. FUNCTION NewMenuBarDefProc(userRoutine: MenuBarDefProcPtr): MenuBarDefUPP;
  104.     {$IFC NOT GENERATINGCFM }
  105.     INLINE $2E9F;
  106.     {$ENDC}
  107.  
  108. FUNCTION NewMenuHookProc(userRoutine: MenuHookProcPtr): MenuHookUPP;
  109.     {$IFC NOT GENERATINGCFM }
  110.     INLINE $2E9F;
  111.     {$ENDC}
  112.  
  113. FUNCTION NewMBarHookProc(userRoutine: MBarHookProcPtr): MBarHookUPP;
  114.     {$IFC NOT GENERATINGCFM }
  115.     INLINE $2E9F;
  116.     {$ENDC}
  117.  
  118. PROCEDURE CallMenuDefProc(message: INTEGER; theMenu: MenuRef; VAR menuRect: Rect; hitPt: Point; VAR whichItem: INTEGER; userRoutine: MenuDefUPP);
  119.     {$IFC NOT GENERATINGCFM}
  120.     INLINE $205F, $4E90;
  121.     {$ENDC}
  122.  
  123. FUNCTION CallMenuBarDefProc(selector: INTEGER; message: INTEGER; parameter1: INTEGER; parameter2: LONGINT; userRoutine: MenuBarDefUPP): LONGINT;
  124.     {$IFC NOT GENERATINGCFM}
  125.     INLINE $205F, $4E90;
  126.     {$ENDC}
  127.  
  128. PROCEDURE CallMenuHookProc(userRoutine: MenuHookUPP);
  129.     {$IFC NOT GENERATINGCFM}
  130.     INLINE $205F, $4E90;
  131.     {$ENDC}
  132.  
  133. FUNCTION CallMBarHookProc(VAR menuRect: Rect; userRoutine: MBarHookUPP): INTEGER;
  134.     {$IFC NOT GENERATINGCFM}
  135.     {To be implemented:  Glue to move parameters according to special case conventions.}
  136.     {$ENDC}
  137.  
  138. TYPE
  139.     MCEntry = RECORD
  140.         mctID:                    INTEGER;                                {menu ID.  ID = 0 is the menu bar}
  141.         mctItem:                INTEGER;                                {menu Item. Item = 0 is a title}
  142.         mctRGB1:                RGBColor;                                {usage depends on ID and Item}
  143.         mctRGB2:                RGBColor;                                {usage depends on ID and Item}
  144.         mctRGB3:                RGBColor;                                {usage depends on ID and Item}
  145.         mctRGB4:                RGBColor;                                {usage depends on ID and Item}
  146.         mctReserved:            INTEGER;                                {reserved for internal use}
  147.     END;
  148.  
  149.     MCEntryPtr = ^MCEntry;
  150.  
  151.     MCTable = ARRAY [0..0] OF MCEntry;
  152.  
  153.     MCTablePtr = ^MCTable;
  154.     MCTableHandle = ^MCTablePtr;
  155.  
  156.     MenuCRsrc = RECORD
  157.         numEntries:                INTEGER;                                {number of entries}
  158.         mcEntryRecs:            MCTable;                                {ARRAY [1..numEntries] of MCEntry}
  159.     END;
  160.  
  161.     MenuCRsrcPtr = ^MenuCRsrc;
  162.     MenuCRsrcHandle = ^MenuCRsrcPtr;
  163.  
  164. FUNCTION GetMBarHeight : INTEGER;
  165.     {$IFC NOT CFMSYSTEMCALLS}
  166.     INLINE $3EB8, $0BAA;            { MOVE.w $0BAA,(SP) }
  167.     {$ENDC}
  168.  
  169. PROCEDURE InitMenus;
  170.     {$IFC NOT GENERATINGCFM}
  171.     INLINE $A930;
  172.     {$ENDC}
  173. FUNCTION NewMenu(menuID: INTEGER; menuTitle: ConstStr255Param): MenuRef;
  174.     {$IFC NOT GENERATINGCFM}
  175.     INLINE $A931;
  176.     {$ENDC}
  177. FUNCTION GetMenu(resourceID: INTEGER): MenuRef;
  178.     {$IFC NOT GENERATINGCFM}
  179.     INLINE $A9BF;
  180.     {$ENDC}
  181. PROCEDURE DisposeMenu(theMenu: MenuRef);
  182.     {$IFC NOT GENERATINGCFM}
  183.     INLINE $A932;
  184.     {$ENDC}
  185. PROCEDURE AppendMenu(menu: MenuRef; data: ConstStr255Param);
  186.     {$IFC NOT GENERATINGCFM}
  187.     INLINE $A933;
  188.     {$ENDC}
  189. PROCEDURE AppendResMenu(theMenu: MenuRef; theType: ResType);
  190.     {$IFC NOT GENERATINGCFM}
  191.     INLINE $A94D;
  192.     {$ENDC}
  193. PROCEDURE InsertResMenu(theMenu: MenuRef; theType: ResType; afterItem: INTEGER);
  194.     {$IFC NOT GENERATINGCFM}
  195.     INLINE $A951;
  196.     {$ENDC}
  197. PROCEDURE InsertMenu(theMenu: MenuRef; beforeID: INTEGER);
  198.     {$IFC NOT GENERATINGCFM}
  199.     INLINE $A935;
  200.     {$ENDC}
  201. PROCEDURE DrawMenuBar;
  202.     {$IFC NOT GENERATINGCFM}
  203.     INLINE $A937;
  204.     {$ENDC}
  205. PROCEDURE InvalMenuBar;
  206.     {$IFC NOT GENERATINGCFM}
  207.     INLINE $A81D;
  208.     {$ENDC}
  209. PROCEDURE DeleteMenu(menuID: INTEGER);
  210.     {$IFC NOT GENERATINGCFM}
  211.     INLINE $A936;
  212.     {$ENDC}
  213. PROCEDURE ClearMenuBar;
  214.     {$IFC NOT GENERATINGCFM}
  215.     INLINE $A934;
  216.     {$ENDC}
  217. FUNCTION GetNewMBar(menuBarID: INTEGER): Handle;
  218.     {$IFC NOT GENERATINGCFM}
  219.     INLINE $A9C0;
  220.     {$ENDC}
  221. FUNCTION GetMenuBar: Handle;
  222.     {$IFC NOT GENERATINGCFM}
  223.     INLINE $A93B;
  224.     {$ENDC}
  225. PROCEDURE SetMenuBar(menuList: Handle);
  226.     {$IFC NOT GENERATINGCFM}
  227.     INLINE $A93C;
  228.     {$ENDC}
  229. PROCEDURE InsertMenuItem(theMenu: MenuRef; itemString: ConstStr255Param; afterItem: INTEGER);
  230.     {$IFC NOT GENERATINGCFM}
  231.     INLINE $A826;
  232.     {$ENDC}
  233. PROCEDURE DeleteMenuItem(theMenu: MenuRef; item: INTEGER);
  234.     {$IFC NOT GENERATINGCFM}
  235.     INLINE $A952;
  236.     {$ENDC}
  237. FUNCTION MenuKey(ch: CHAR): LONGINT;
  238.     {$IFC NOT GENERATINGCFM}
  239.     INLINE $A93E;
  240.     {$ENDC}
  241. PROCEDURE HiliteMenu(menuID: INTEGER);
  242.     {$IFC NOT GENERATINGCFM}
  243.     INLINE $A938;
  244.     {$ENDC}
  245. PROCEDURE SetMenuItemText(theMenu: MenuRef; item: INTEGER; itemString: ConstStr255Param);
  246.     {$IFC NOT GENERATINGCFM}
  247.     INLINE $A947;
  248.     {$ENDC}
  249. PROCEDURE GetMenuItemText(theMenu: MenuRef; item: INTEGER; VAR itemString: Str255);
  250.     {$IFC NOT GENERATINGCFM}
  251.     INLINE $A946;
  252.     {$ENDC}
  253. PROCEDURE DisableItem(theMenu: MenuRef; item: INTEGER);
  254.     {$IFC NOT GENERATINGCFM}
  255.     INLINE $A93A;
  256.     {$ENDC}
  257. PROCEDURE EnableItem(theMenu: MenuRef; item: INTEGER);
  258.     {$IFC NOT GENERATINGCFM}
  259.     INLINE $A939;
  260.     {$ENDC}
  261. PROCEDURE CheckItem(theMenu: MenuRef; item: INTEGER; checked: BOOLEAN);
  262.     {$IFC NOT GENERATINGCFM}
  263.     INLINE $A945;
  264.     {$ENDC}
  265. PROCEDURE SetItemMark(theMenu: MenuRef; item: INTEGER; markChar: CHAR);
  266.     {$IFC NOT GENERATINGCFM}
  267.     INLINE $A944;
  268.     {$ENDC}
  269. PROCEDURE GetItemMark(theMenu: MenuRef; item: INTEGER; VAR markChar: CHAR);
  270.     {$IFC NOT GENERATINGCFM}
  271.     INLINE $A943;
  272.     {$ENDC}
  273. PROCEDURE SetItemIcon(theMenu: MenuRef; item: INTEGER; iconIndex: INTEGER);
  274.     {$IFC NOT GENERATINGCFM}
  275.     INLINE $A940;
  276.     {$ENDC}
  277. PROCEDURE GetItemIcon(theMenu: MenuRef; item: INTEGER; VAR iconIndex: Byte);
  278.     {$IFC NOT GENERATINGCFM}
  279.     INLINE $A93F;
  280.     {$ENDC}
  281. PROCEDURE SetItemStyle(theMenu: MenuRef; item: INTEGER; chStyle: Style);
  282.     {$IFC NOT GENERATINGCFM}
  283.     INLINE $A942;
  284.     {$ENDC}
  285. PROCEDURE GetItemStyle(theMenu: MenuRef; item: INTEGER; VAR chStyle: Style);
  286. PROCEDURE CalcMenuSize(theMenu: MenuRef);
  287.     {$IFC NOT GENERATINGCFM}
  288.     INLINE $A948;
  289.     {$ENDC}
  290. FUNCTION CountMItems(theMenu: MenuRef): INTEGER;
  291.     {$IFC NOT GENERATINGCFM}
  292.     INLINE $A950;
  293.     {$ENDC}
  294. FUNCTION GetMenuHandle(menuID: INTEGER): MenuRef;
  295.     {$IFC NOT GENERATINGCFM}
  296.     INLINE $A949;
  297.     {$ENDC}
  298. PROCEDURE FlashMenuBar(menuID: INTEGER);
  299.     {$IFC NOT GENERATINGCFM}
  300.     INLINE $A94C;
  301.     {$ENDC}
  302. PROCEDURE SetMenuFlash(count: INTEGER);
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $A94A;
  305.     {$ENDC}
  306. FUNCTION MenuSelect(startPt: Point): LONGINT;
  307.     {$IFC NOT GENERATINGCFM}
  308.     INLINE $A93D;
  309.     {$ENDC}
  310. PROCEDURE InitProcMenu(resID: INTEGER);
  311.     {$IFC NOT GENERATINGCFM}
  312.     INLINE $A808;
  313.     {$ENDC}
  314. PROCEDURE GetItemCmd(theMenu: MenuRef; item: INTEGER; VAR cmdChar: CHAR);
  315.     {$IFC NOT GENERATINGCFM}
  316.     INLINE $A84E;
  317.     {$ENDC}
  318. PROCEDURE SetItemCmd(theMenu: MenuRef; item: INTEGER; cmdChar: CHAR);
  319.     {$IFC NOT GENERATINGCFM}
  320.     INLINE $A84F;
  321.     {$ENDC}
  322. FUNCTION PopUpMenuSelect(menu: MenuRef; top: INTEGER; left: INTEGER; popUpItem: INTEGER): LONGINT;
  323.     {$IFC NOT GENERATINGCFM}
  324.     INLINE $A80B;
  325.     {$ENDC}
  326. FUNCTION MenuChoice: LONGINT;
  327.     {$IFC NOT GENERATINGCFM}
  328.     INLINE $AA66;
  329.     {$ENDC}
  330. PROCEDURE DeleteMCEntries(menuID: INTEGER; menuItem: INTEGER);
  331.     {$IFC NOT GENERATINGCFM}
  332.     INLINE $AA60;
  333.     {$ENDC}
  334. FUNCTION GetMCInfo: MCTableHandle;
  335.     {$IFC NOT GENERATINGCFM}
  336.     INLINE $AA61;
  337.     {$ENDC}
  338. PROCEDURE SetMCInfo(menuCTbl: MCTableHandle);
  339.     {$IFC NOT GENERATINGCFM}
  340.     INLINE $AA62;
  341.     {$ENDC}
  342. PROCEDURE DisposeMCInfo(menuCTbl: MCTableHandle);
  343.     {$IFC NOT GENERATINGCFM}
  344.     INLINE $AA63;
  345.     {$ENDC}
  346. FUNCTION GetMCEntry(menuID: INTEGER; menuItem: INTEGER): MCEntryPtr;
  347.     {$IFC NOT GENERATINGCFM}
  348.     INLINE $AA64;
  349.     {$ENDC}
  350. PROCEDURE SetMCEntries(numEntries: INTEGER; menuCEntries: MCTablePtr);
  351.     {$IFC NOT GENERATINGCFM}
  352.     INLINE $AA65;
  353.     {$ENDC}
  354. PROCEDURE InsertFontResMenu(theMenu: MenuRef; afterItem: INTEGER; scriptFilter: INTEGER);
  355.     {$IFC NOT GENERATINGCFM}
  356.     INLINE $303C, $0400, $A825;
  357.     {$ENDC}
  358. PROCEDURE InsertIntlResMenu(theMenu: MenuRef; theType: ResType; afterItem: INTEGER; scriptFilter: INTEGER);
  359.     {$IFC NOT GENERATINGCFM}
  360.     INLINE $303C, $0601, $A825;
  361.     {$ENDC}
  362. FUNCTION SystemEdit(editCmd: INTEGER): BOOLEAN;
  363.     {$IFC NOT GENERATINGCFM}
  364.     INLINE $A9C2;
  365.     {$ENDC}
  366. PROCEDURE SystemMenu(menuResult: LONGINT);
  367.     {$IFC NOT GENERATINGCFM}
  368.     INLINE $A9B5;
  369.     {$ENDC}
  370. {$IFC OLDROUTINENAMES }
  371. PROCEDURE AddResMenu(theMenu: MenuRef; theType: ResType);
  372.     {$IFC NOT GENERATINGCFM}
  373.     INLINE $A94D;
  374.     {$ENDC}
  375. PROCEDURE InsMenuItem(theMenu: MenuRef; itemString: ConstStr255Param; afterItem: INTEGER);
  376.     {$IFC NOT GENERATINGCFM}
  377.     INLINE $A826;
  378.     {$ENDC}
  379. PROCEDURE DelMenuItem(theMenu: MenuRef; item: INTEGER);
  380.     {$IFC NOT GENERATINGCFM}
  381.     INLINE $A952;
  382.     {$ENDC}
  383. PROCEDURE SetItem(theMenu: MenuRef; item: INTEGER; itemString: ConstStr255Param);
  384.     {$IFC NOT GENERATINGCFM}
  385.     INLINE $A947;
  386.     {$ENDC}
  387. PROCEDURE GetItem(theMenu: MenuRef; item: INTEGER; VAR itemString: Str255);
  388.     {$IFC NOT GENERATINGCFM}
  389.     INLINE $A946;
  390.     {$ENDC}
  391. FUNCTION GetMHandle(menuID: INTEGER): MenuRef;
  392.     {$IFC NOT GENERATINGCFM}
  393.     INLINE $A949;
  394.     {$ENDC}
  395. PROCEDURE DelMCEntries(menuID: INTEGER; menuItem: INTEGER);
  396.     {$IFC NOT GENERATINGCFM}
  397.     INLINE $AA60;
  398.     {$ENDC}
  399. PROCEDURE DispMCInfo(menuCTbl: MCTableHandle);
  400.     {$IFC NOT GENERATINGCFM}
  401.     INLINE $AA63;
  402.     {$ENDC}
  403. {$ENDC}
  404.  
  405. {$ALIGN RESET}
  406. {$POP}
  407.  
  408. {$SETC UsingIncludes := MenusIncludes}
  409.  
  410. {$ENDC} {__MENUS__}
  411.  
  412. {$IFC NOT UsingIncludes}
  413.  END.
  414. {$ENDC}
  415.